The present application relates to software and more specifically to user interface designs and methods for facilitating efficient user access to data and software functionality.
User interface designs and accompanying methods for facilitating user access to data and software functionality are employed in various demanding applications, including enterprise, scientific research, financial analysis, and ecommerce applications. Such application often demand user friendly applications that facilitate efficient management of application windows and content to enable rapid performance of tasks and user access to requisite data and functionality without requiring undue navigation through software menus, windows, and so on.
Efficient methods for manipulating application windows and facilitating data access are particularly important in enterprise applications, such as Customer Relationship Management (CRM) applications, which often demand features for user management of complex simultaneous tasks involving multiple instances of running applications and/or application windows.
For example, a customer service agent working with a CRM application may simultaneously assist several customers via electronic chat. This may involve a user opening potentially hundreds of application windows, running multiple simultaneous software processes, performing multiple data retrieval steps, and so on. Conventionally, changes to one window may not be updated in a related window (i.e., the windows are not synchronized), and important windows may become buried and lost behind other less important windows. Typically, users must manually switch to windows with relevant content when they switch context (e.g., when a user switches from assisting one customer to assisting another customer). Work may be interrupted when windows become disorganized and when content is lost among open windows.
To address problems with multiple overlapping windows, agents may employ very large monitors or several monitors over which application windows may be dispersed. However, important windows may remain obscured behind other windows, and windows may remain relatively disorganized and camouflaged among other similar looking windows.
Generally, conventional software applications often attempt to incorporate as much data and functionality as possible into a single primary view, e.g., webpage or application window. Application features and functionality are often optimized for a primary task performed in the primary window. Additional windows may be spawned for secondary tasks, but these windows often obscure features and user interface controls of the primary window. This can be problematic even in cases involving only a few open windows.
A primary window may have sub-windows or sections that contain summarized data. However, summarized data may lack requisite detail for a given task. In addition, complex tasks or simultaneous tasks may require access to more data and more granular views of data than can fit within a single view.
Typically only a subset of data, windows, and tools are visible and readily accessible or available at a given time. This may further inhibit rapid performance of secondary tasks, e.g., involving cross-referencing of data, and so on, when requisite windows do not fit within a single view. This may reduce worker productivity and cause user frustration, as a user must stop working on a primary task to navigate to different part of the application or website to perform a secondary task.
In certain cases, to avoid tedious navigation within a single view, users run multiple instances of an application concurrently to access requisite data. However, work interruptions and human error may still occur when windows become disorganized and when content is lost among multiple unsynchronized open windows.
Hence, conventional software applications often lack effective mechanisms for enabling efficient access to data and functionality, and may further suffer from data synchronization problems. These problems become increasingly problematic when more software tasks are addressed approximately in parallel or when working on complex tasks involving multiple windows, data sets, and software processes.